Detects RTT increases during slow start before actual packet loss,
reducing bufferbloat on the first congestion event.

- Standard → CSS transition on RTT increase above eta threshold
- CSS grows by MSS/4 per ACK (vs MSS in standard slow start)
- CSS exits to congestion avoidance after 5 consecutive rounds
- CSS returns to standard if RTT stabilizes
- Round tracking via largest_sent_pn boundary
- Connection passes latest_rtt and largest_sent_pn to CC on ACK

When the pacer requests a delay < 1ms, sleep inline in the send loop
instead of returning to the event loop (which has only ms-resolution
timers). This gives ~microsecond pacing precision for high-throughput
transfers, similar to the Linux kernel QUIC's hrtimer approach.

Applied to both Server and Client event loops.

For the common case where stream data arrives in order (offset == read_pos
and no buffered chunks), stores data in a fixed 1500-byte inline buffer
instead of going through the AutoArrayHashMap. This eliminates hash map
insert/lookup/orderedRemove operations on the hot path.

Inspired by lxin/quic kernel's approach of minimizing per-frame allocation.
The pop() path still returns heap-allocated data for caller ownership
compatibility, but the push() path saves hash map overhead.

Two optimizations for the stream frame reassembly hot path:

1. Inline buffer: when data arrives in-order (offset == read_pos) and no
   out-of-order chunks are buffered, copy to a fixed 1500-byte inline
   buffer instead of going through AutoArrayHashMap operations. Avoids
   hash map insert on push for the common case.

2. swapRemove instead of orderedRemove in pop(): O(1) instead of O(n)
   for removing consumed chunks from the hash map. Order doesn't matter
   since lookup is by key (offset), not position.